library(tidyverse)
demographics = read.csv('data/demos_anonymized.csv')
ids = read.csv('data/ids_anonymized.csv')
model_variables = read.csv('data/model_variables_anonymized.csv')

Introduction

Get a Quick Summary

It’s always a good idea to glance at the data

Grouping and Summarizing Operations

A very common operation is to do things by group(s) then create new summary variables.

Grouping and Summarizing Operations

Do multiple operations at once

Mapping functions to groups

We’ll use the map function to map the sum function to each element in the list

Grouping and Summarizing Operations

We can even do this with modeling and other operations.

This extracts the coefficients from a model run for each group.

Visualization

Visualizing data requires that you: - Consider carefully the information you want to display - And then how you want to display it

Tell a story with the data.

And have some fun with it!

ggplot2

The most widely used visualization package in R

Layers

Visualization can be thought of in a layered fashion

Start with the base, then build up

More pipes

ggplot2 uses a + as a pipe to add layers

We can pipe to any ggplot as we did before (%>%)

Aesthetics

Aesthetics (aes) map variables to visual properties

Geoms are the geometric units we want to display

Aesthetics

Stats

We can also use ggplot2 to create statistics we want to visualize

Typically used indirectly when geoms are called

Can be used for more direct control

Scales

Scales are used to add specifications to axes, colors, etc.

Facets

Facets allow another dimension to plots by group

Themes

Themes allow for customization

Two uses of a - a built-in versions (e.g. theme_minimal) - DIY (theme(…))

For the theme function, each argument, takes on a specific value or an element function:

Themes

Interactivity

Interactivity is a must-have tool for web-based presentation

Use to enhance exploration of the data - Not just because one can

Allows for additional dimensions

Even useful for exploring raw data

Interactivity

General

Interactivity

Specific functionality:

Plotly

traces - add_, work similar to geoms

modes - allow for points, lines, text and combinations

aesthetics - variables are denoted with ~, constants do not use - x =~ var1 vs x = 2

Plotly

Plotly uses the standard pipe %>%

Plotly

Plotly

Plotly

Use ggplotly to turn our formerly static plots into interactive ones.

Python examples

Visualization

matplotlib is the most common visualization module in Python, though it’s fairly dated at this point. As such we’ll use a ggplot implementation in python called plotnine.

Unfortunately for plotly, the interactivity makes it unusable within the R notebook (at present), so you may need to switch to Anaconda or other IDE to try other modules like plotly. Even Python users will still use R for easier visualization though, so feel free to do what you like there, then use ggplot etc. in R when the time comes.

That said, I’ll show a couple plots

---
title: "Module 2: Summarizing and Visualizing Data"
output: 
  html_notebook: 
    highlight: pygments
    theme: sandstone
    css: other.css
editor_options: 
  chunk_output_type: inline
---

```{r init, echo=FALSE}
# these options are primary useful to the creation of the html document
knitr::opts_chunk$set(
  echo=T, 
  eval = F,
  message = F, 
  warning = F, 
  comment = NA,
  R.options=list(width=120), 
  cache.rebuild=F, 
  cache=F,
  fig.align='center', 
  fig.asp = .7,
  dev = 'svg', 
  dev.args=list(bg = 'transparent')
)
```

```{r catchup, eval=TRUE}
library(tidyverse)
demographics = read.csv('data/demos_anonymized.csv')
ids = read.csv('data/ids_anonymized.csv')
model_variables = read.csv('data/model_variables_anonymized.csv')
```

## Introduction

## Get a Quick Summary

It's always a good idea to glance at the data

```{r summary}
glimpse(demographics)
```
```{r}
summary(demographics[,1:10])
```



## Grouping and Summarizing Operations

A very common operation is to do things by group(s) then create new summary variables.

```{r group_by, eval=TRUE}
demographics %>% 
  group_by(libuser) %>% 
  summarise(age = mean(age, na.rm = T)) 
```



## Grouping and Summarizing Operations

Do multiple operations at once

```{r group_by2, eval=TRUE}
demographics %>% 
  group_by(libuser) %>% 
  summarise(age_mean = mean(age, na.rm = T),
            age_sd = sd(age, na.rm = T),
            age_max = max(age, na.rm = T),
            prop_male = mean(gender=='Male', na.rm = T)) 
```



##  Mapping functions to groups

We’ll use the `map` function to *map* the `sum` function to each element in the list

```{r map, eval=TRUE}
x = list(1:3, 4:6, 7:9)
map(x, sum)
```



## Grouping and Summarizing Operations

We can even do this with modeling and other operations. 

This extracts the coefficients from a model run for each group.

```{r group_by3, eval=TRUE}
demographics %>% 
  drop_na(race) %>% 
  group_split(race) %>%   
  map(~lm(award_total_amount ~ gender, data = .))
```


## Visualization

Visualizing data requires that you:
- Consider carefully the information you want to display
- And then how you want to display it

Tell a story with the data.

And have some fun with it!


## ggplot2

The most widely used visualization package in R



## Layers

Visualization can be thought of in a layered fashion

Start with the base, then build up

## More pipes

`ggplot2` uses a `+` as a pipe to add layers

```{r ggplot2, eval=FALSE}
library(ggplot2)
ggplot(data) +
  geom_point(aes(x = var1, y = var2)) +
  geom_line() +
  theme(plot.caption = element_text(size = 6))
```

We can pipe *to* any ggplot as we did before (` %>% `)



## Aesthetics

**Aesthetics** (`aes`) map variables to visual properties

**Geoms** are the geometric units we want to display


## Aesthetics

```{r aesthetics}
model_variables %>% 
  filter(award_total_amount > 1e7) %>% 
  ggplot() +
  geom_density(aes(x = award_total_amount, 
                   color = factor(gender),
                   fill = factor(gender)),
               alpha = .2) + 
  scale_x_continuous(breaks = (1:10) * 1e7, trans = 'log')
```

```{r aesthetics2}
demographics %>% 
  filter(award_year_start < 2020 & award_year_start > 1990) %>%  
  ggplot(aes(award_year_start, award_total_log)) + 
  geom_smooth(aes(color=factor(libuser)))
```


## Stats

We can also use ggplot2 to create statistics we want to visualize

Typically used indirectly when geoms are called

Can be used for more direct control

```{r ggstats2}
ggplot(model_variables, aes(age, award_total_amount)) +
  geom_point(alpha = .02) +
  stat_ellipse(color = '#ff5500')
```



## Scales

Scales are used to add specifications to axes, colors, etc.

```{r scales}
model_variables %>% 
  filter(award_total_amount >= 1e6) %>% 
  ggplot() +
  geom_density(aes(x = award_total_amount, 
                   color = gender,
                   fill = gender),
               alpha = .2) + 
  scale_x_continuous(breaks = c(1e6, 5e6, 1e7, 2.5e7, 5e7), 
                     trans = 'log') +
  scale_fill_viridis_d(begin = .25, end = .5) +
  scale_color_viridis_d(begin = .25, end = .5) 
```


## Facets

Facets allow another dimension to plots by group

- **facet_grid**: returns a matrix of like dimensions
- **facet_wrap**: more flexible specification

```{r facets}
model_variables %>% 
  ggplot() +
  geom_density(aes(x = award_total_amount, 
                   color = libuser,
                   fill = libuser),
               alpha = .2) +
  facet_wrap(~gender)
```




## Themes

`Themes` allow for customization

Two uses of a 
- a built-in versions (e.g. `theme_minimal`)
- DIY  (`theme`(...))

For the theme function, each argument, takes on a specific value or an element function:

- `element_rect`
- `element_line`
- `element_text`
- `element_blank`


## Themes

```{r themes1}
model_variables %>% 
  ggplot() +
  geom_smooth(aes(x = age,
                y = award_total_amount,
                color = libuser),
               alpha = .2) + 
  theme_minimal()
```


```{r themes2}
model_variables %>% 
  ggplot() +
  geom_smooth(aes(x = age,
                y = award_total_amount,
                color = libuser),
               alpha = .2) + 
  theme(axis.text.x = element_text(size=12),
        panel.grid.minor.x = element_blank(),
        plot.background = element_rect(color = 'rosybrown'),
        panel.background = element_rect(fill = 'papayawhip'))
```

## Interactivity

Interactivity is a must-have tool for web-based presentation

Use to enhance exploration of the data
- Not just because one can

Allows for additional dimensions

Even useful for exploring raw data



## Interactivity


General 

- [plotly](https://plot.ly/r/)
  - also used in Python, Matlab, Julia
  - can convert `ggplot2` images to interactive ones
  
- [highcharter](http://jkunst.com/highcharter/)
  - general wrapper for highcharts.js 
  - works with some R packages out of the box
  
- [rbokeh](http://hafen.github.io/rbokeh/)
  - like plotly, it also has cross language support



## Interactivity

Specific functionality:

- [DT](https://rstudio.github.io/DT/)
  - interactive data tables
  
- [leaflet](https://rstudio.github.io/leaflet/)
    - maps with OpenStreetMap
    
- [visNetwork](http://datastorm-open.github.io/visNetwork/)
    - Network visualization
    


## Plotly

`traces`
- `add_`, work similar to geoms
  
`modes`
- allow for points, lines, text and combinations

`aesthetics`
- variables are denoted with `~`, constants do not use
- `x =~ var1` vs `x = 2`




## Plotly

Plotly uses the standard pipe `%>%`

```{r plotly}
library(plotly)

model_variables %>% 
  plot_ly(x = ~gender, y = ~ age) %>% 
  add_boxplot(color =~ gender)
```



## Plotly

```{r plotly1}
library(plotly)

model_variables %>% 
  group_by(libuser, gender) %>% 
  summarise(award = mean(award_total_amount)) %>% 
  plot_ly(x = ~libuser, 
          y = ~award, 
          color = ~gender,
          text = ~round(award), 
          textposition = 'auto', 
          type = 'bar') %>% 
  layout(bargap = 0.25, 
         bargroupgap = 0.25)
```



## Plotly

```{r plotly2}
init = glm(award_total_amount >= 5000000 ~ age*libuser, 
           data = model_variables, 
           family = binomial)

model_variables %>% 
  modelr::add_predictions(init, type = 'response') %>% 
  plot_ly(x = ~age, y = ~ pred) %>% 
  add_lines(color =~ libuser, line = list(shape = "spline")) %>% 
  layout(title = 'Predicted Prob. Award > 1 mil')
```



## Plotly

Use ggplotly to turn our formerly static plots into interactive ones. 

```{r plotly3}
p = model_variables %>% 
  ggplot() +
  geom_density(aes(x = log(award_total_amount), 
                   color = libuser,
                   fill = libuser),
               alpha = .2) + 
  facet_wrap(~ gender) 
ggplotly()
```




## Python examples

### Init

```{python py_init, engine.path= '/Users/micl/anaconda3/bin/python'}
import pandas as pd
import numpy as np

demographics = pd.read_csv('data/demos_anonymized.csv')
ids = pd.read_csv('data/ids_anonymized.csv')
model_variables = pd.read_csv('data/model_variables_anonymized.csv')
```


###  Grouping and Summarizing data

```{python py_summary}
demographics.describe(include = 'all')
```
```{python py_summary_numeric}
demographics.describe(include = [np.number])
```

```{python py_summary_string}
demographics.describe(include = [np.object])
```




```{python py_group_by, eval=TRUE}
lib_group = demographics.groupby('libuser', sort=True, )

# automatically chooses numeric
lib_group.mean()
```


```{python py_group_by2, eval=TRUE}
lib_group.get_group(0).head()
```


```{python py_group_by3, eval=TRUE}
lib_group.size()
```

```{python py_group_by4, eval=TRUE}
lib_group.describe()
```
### Mapping a function

```{python py_map}
x = [[1,2,3], [4,5,6], [7,8,9]]
list(map(np.sum, x))
```

```{python py_map2}
demographics.select_dtypes('number').apply(np.mean)
```


### Visualization

`matplotlib` is the most common visualization module in Python, though it's fairly dated at this point. As such we'll use a ggplot implementation in python called `plotnine`.

Unfortunately for plotly, the interactivity makes it unusable within the R notebook (at present), so you may need to switch to Anaconda or other IDE to try other modules like `plotly`.  Even Python users will still use R for easier visualization though, so feel free to do what you like there, then use ggplot etc. in R when the time comes.

That said, I'll show a couple plots

```{python plotnine}
import plotnine
```

```{python gg1}
dplot = demographics[(demographics.award_year_start < 2020) & (demographics.award_year_start > 1990) & (demographics.award_total_log > 11)]
dplot
ggplot(dplot, aes(x='award_year_start', y='award_total_log')) + geom_smooth(aes(group = 'libuser', color = 'libuser'))
```


```{python gg2}
year_award_average = demographics[demographics.libuser == 1].groupby(['award_home_dept', 'award_year_start']).mean()
year_award_average
```



```{python py_plotly_init}
import plotly
import plotly.plotly as py
from plotly.offline import init_notebook_mode
import plotly.graph_objs as go
plotly.offline.init_notebook_mode(connected=True)
```


```{python py_plotly}
y0 = np.random.randn(50)-1
y1 = np.random.randn(50)+1

trace0 = go.Box(
    y=y0
)
trace1 = go.Box(
    y=y1
)
data = [trace0, trace1]
py.iplot(data)
```


```{python}
```
